home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok59.lha / AmokEd_V1.02b / txt / EdCmd2.mod < prev    next >
Text File  |  1993-08-15  |  16KB  |  635 lines
  1. (*************************************************************************
  2.  
  3. :Program.    EdCmd2.mod
  4. :Contents.   Commands for AmokEd
  5. :Author.     Hartmut Goebel
  6. :Language.   Oberon
  7. :Translator. Amiga Oberon Compiler V2.00
  8. :Imports.    SupLib (Hartmut Goebel)
  9. :History.    V0.1, 23 Mar 1991 Hartmut Goebel
  10. :History.    V1.0, 14 Apr 1991 Hartmut Goebel [hG]
  11. :History.    V1.0b 28 Apr 1991 [hG] changed doNewWindow <- edL.TextInit
  12. :History.    V1.0c 06 Jun 1991 [hG] +Vars lineno, colno
  13. :History.    V1.1  12 Jun 1991 [hG] Scanf complited (SScanf v. V.Rudolph)
  14. :History.    V1.1b 17 Jun 1991 [hG] eigener Screen möglich
  15. :Date.       18 Oct 1991 21:36:31
  16.  
  17. *************************************************************************)
  18.  
  19. MODULE EdCmd2;
  20. (* $Debug- *)
  21. IMPORT
  22.   cv:  Conversions,
  23.   d:   Dos,
  24.   e:   Exec,
  25.   edD: EdDisplay,
  26.   edE: EdErrors,
  27.   edG: EdGlobalVars,
  28.   edK: EdKeyboard,
  29.   edL: EdLowLevel,
  30.   eGd: EdGadgets,
  31.   eMn: EdMenu,
  32.   g:   Graphics,
  33.   I:   Intuition,
  34.   lst: EdLists,
  35.   ol:  OberonLib,
  36.   sl:  SupLib,
  37.   str: Strings,
  38.   sys: SYSTEM;
  39.  
  40. TYPE
  41.   Variable = STRUCT (node: lst.Node)
  42.     name: edG.StringPtr;
  43.     string: edG.StringPtr;
  44.   END;
  45.   VarPtr = POINTER TO Variable;
  46.  
  47.   (* WICHTIG: Bei Änderungen Offsets in FindReplace.asm überprüfen!! *)
  48.   FindReplaceStruct = STRUCT
  49.     findStr: edG.StringPtr;
  50.     line: edG.LinePtr;
  51.     flen: INTEGER;
  52.     pos: INTEGER;
  53.   END;
  54.  
  55. CONST
  56.   (* Flags für einzelne Kommandos *)
  57.   replace*=0;
  58.   previous*=1;
  59.   oldStrings*=2;
  60.   top*=0;
  61.   height*=1;
  62.   temp*=2;
  63.   leftEdge*={top,height};
  64.  
  65.   ReplaceQuestion = "Replace? (y/n/a/q)";
  66.   NoFindPattern = "No find pattern";
  67.   NoReplacePattern = "No replace pattern";
  68.   PatternNotFound = "Pattern Not Found";
  69.   ReplaceLineTooLong = "Replace: Line Too Long";
  70.   WindowTooBig = "window too big (try moving to upper left corner and retrying)";
  71.   ExecuteFailed = "Execute failed!";
  72.  
  73. VAR
  74.   VarList: lst.List;
  75.   VarBuffer: ARRAY 14 OF CHAR;
  76.  
  77. (*-----------------------------------------------------------------------*)
  78.  
  79. PROCEDURE doUndo*;
  80. BEGIN
  81.   edD.TextLoad;
  82.   edD.TextRedisplayCurrentLine;
  83. END doUndo;
  84.  
  85.  
  86. PROCEDURE doNull*; (* macht absolut nichts *)
  87. BEGIN END doNull;
  88.  
  89.  
  90. PROCEDURE doAbort*; (* subject of change *)
  91. BEGIN
  92.   edG.Rc := edE.AbortLevel;
  93. END doAbort;
  94.  
  95.  
  96. PROCEDURE doVersion*;
  97. BEGIN
  98.   edL.Title(edG.Version); edG.Rc := edE.cmdValid2;
  99. END doVersion;
  100.  
  101. (*-----------------------------------------------------------------------*)
  102.  
  103. PROCEDURE doTLate*;
  104. VAR
  105.   ch: CHAR;
  106.   long: LONGINT;
  107. BEGIN
  108.   IF NOT edL.StrToInt(edG.Arg[0],long) OR (long > 255) THEN
  109.     edG.Rc := edE.cmdError; edL.Title(edG.BadArgument);
  110.     RETURN;
  111.   END;
  112.   ch := edG.LineBuffer[edG.Text.pos];
  113.   IF ch = 0X THEN
  114.     ch := 20X; END;
  115.   IF edG.Arg[0][0] < "0" THEN (* mit Vorzeichen => relativ *)
  116.     ch := CHR(ORD(edG.LineBuffer[edG.Text.pos])+long);
  117.   ELSE
  118.     ch := CHR(long);
  119.   END;
  120.   IF ch # 0X THEN
  121.     IF edG.LineBuffer[edG.Text.pos] = 0X THEN (* letztes Zeichen *)
  122.       INC(edG.LineBufferLen);
  123.       edG.LineBuffer[edG.LineBufferLen] := 0X;
  124.     END;
  125.     edG.LineBuffer[edG.Text.pos] := ch;
  126.     IF NOT (edG.NoScreenUpdate > 0) THEN
  127.       edL.MoveToCursor;
  128.       edD.SetPen(edG.Text.line);
  129.       edG.Arg[1] := sys.ADR(edG.LineBuffer[edG.Text.pos]);
  130.       g.Text(edG.RPort,edG.Arg[1]^,1);
  131.     END;
  132.   END;
  133. END doTLate;
  134.  
  135. (*-----------------------------------------------------------------------*)
  136.  
  137. PROCEDURE doScanf*;
  138. CONST
  139.   StrLen = 80;
  140. VAR
  141.   i,j:INTEGER;
  142.   maxWidth:INTEGER;
  143.   allAllowed:BOOLEAN;
  144.   negAllowed:BOOLEAN;
  145.   allowedChars:ARRAY StrLen OF CHAR;
  146.   fmtLen:INTEGER;
  147.   argLen:INTEGER;
  148.   argStr: edG.StringPtr;
  149.  
  150.   PROCEDURE IsAllowed(ch:CHAR):BOOLEAN;
  151.   VAR
  152.     i:INTEGER;
  153.   BEGIN
  154.     IF ch = ' ' THEN RETURN FALSE END;
  155.     IF allAllowed THEN RETURN TRUE END;
  156.     i := 0;
  157.     WHILE (allowedChars[i] # ch) AND
  158.           (allowedChars[i] # 0X) DO
  159.       INC(i);
  160.     END; (* WHILE *)
  161.     IF allowedChars[i] = 0X THEN
  162.       RETURN negAllowed
  163.     ELSE
  164.       RETURN NOT negAllowed;
  165.     END;(* IF *)
  166.   END IsAllowed;
  167.  
  168.   PROCEDURE BadArgument;
  169.   BEGIN
  170.     edG.Rc := edE.cmdError; edL.Title(edG.BadArgument);
  171.   END BadArgument;
  172.  
  173. BEGIN
  174.   i := 0;
  175.   argStr := sys.ADR(edG.LineBuffer[edG.Text.pos]);
  176.   fmtLen := str.Length(edG.Arg[0]^);
  177.   argLen := str.Length(argStr^);;
  178.   DISPOSE(edG.ScanStr);
  179.  
  180.   (* scan format string *)
  181.  
  182.   (* skip leading garbage *)
  183.   i := 0;
  184.   WHILE (i < fmtLen) AND (edG.Arg[0][i] # '%') DO
  185.     INC(i); END;
  186.   IF i = fmtLen THEN
  187.     BadArgument; RETURN;
  188.   END;
  189.  
  190.   (* check for '*' (ignore argument) *)
  191.   INC(i);
  192.   IF edG.Arg[0][i] = '*' THEN RETURN END;
  193.  
  194.   (* calculate maximal width of string *)
  195.   maxWidth := 0;
  196.   WHILE (i < fmtLen) AND
  197.         (edG.Arg[0][i] >= '0') AND
  198.         (edG.Arg[0][i] <= '9') DO
  199.     maxWidth := maxWidth * 10 + ORD(edG.Arg[0][i])-ORD('0');
  200.     INC(i);
  201.   END; (* WHILE *)
  202.   IF i = fmtLen THEN
  203.     BadArgument; RETURN;
  204.   END;
  205.   IF maxWidth = 0 THEN maxWidth := edG.MaxLineLength-1 END;
  206.  
  207.   (* is conversion-specifier 's' or '[..]' ? *)
  208.   IF edG.Arg[0][i] = 's' THEN
  209.     allAllowed := TRUE;
  210.   ELSIF edG.Arg[0][i] = '[' THEN
  211.     allAllowed := FALSE;
  212.     negAllowed := FALSE;
  213.  
  214.     (* check for negation flags '~' and '^' *)
  215.     INC(i);
  216.     IF (edG.Arg[0][i] = '~') OR (edG.Arg[0][i] = '^') THEN
  217.       negAllowed := TRUE;
  218.       INC(i);
  219.     END; (* IF *)
  220.  
  221.     j := 0;
  222.     allowedChars := "";
  223.     WHILE (i < fmtLen) AND
  224.           (j < (StrLen-1)) AND
  225.           (edG.Arg[0][i] # ']') DO
  226.       allowedChars[j] := edG.Arg[0][i];
  227.       INC(i);
  228.       INC(j);
  229.     END; (* WHILE *)
  230.     allowedChars[j] := 0X;
  231.     IF edG.Arg[0][i] # ']' THEN
  232.       BadArgument; RETURN;
  233.     END;
  234.   ELSE
  235.     BadArgument; RETURN;
  236.   END; (* IF *)
  237.  
  238.   (* scan argument string *)
  239.  
  240.   (* skip leading blanks in argStr *)
  241.   i := 0;
  242.   WHILE (i < argLen) AND (argStr[i] = ' ') DO
  243.     INC(i); END;
  244.  
  245.   j := 0;
  246.   WHILE (i < argLen) AND
  247.         (j < maxWidth) AND
  248.         IsAllowed(argStr[i]) DO
  249.     INC(i);
  250.     INC(j);
  251.   END; (* WHILE *)
  252.  
  253.   ol.New(edG.ScanStr,j+1);
  254.   IF edG.ScanStr=NIL THEN
  255.     INCL(edG.Status,edG.memoryFail); edG.Rc := edE.cmdSevere;
  256.     RETURN;
  257.   END;
  258.   e.CopyMem(edG.LineBuffer[edG.Text.pos],edG.ScanStr^,j);
  259.   edG.ScanStr[j] := 0X;
  260.   edL.Title(edG.ScanStr^); edG.Rc := edE.cmdValid2;
  261. END doScanf;
  262.  
  263. (*-------------------------------------------------------------------------*)
  264.  
  265. PROCEDURE ReleaseVar(var: lst.NodePtr);
  266. BEGIN
  267.   lst.Remove(VarList,var);
  268.   DISPOSE(var(Variable).string);
  269.   (*DISPOSE(var(Variable).name);  wird mit var alocciert *)
  270.   DISPOSE(var);
  271. END ReleaseVar;
  272.  
  273.  
  274. PROCEDURE doSet*;
  275. VAR
  276.   var: lst.NodePtr;
  277.   len: INTEGER;
  278.  
  279.   PROCEDURE SetString;
  280.   BEGIN
  281.     len := str.Length(edG.Arg[1]^)+1;
  282.     ol.New(var(Variable).string,len);
  283.     IF var(Variable).string = NIL THEN
  284.       edG.Rc := edE.cmdSevere; INCL(edG.Status,edG.memoryFail);
  285.       ReleaseVar(var);
  286.       RETURN;
  287.     END;
  288.     e.CopyMem(edG.Arg[1]^,var(Variable).string^,len);
  289.   END SetString;
  290.  
  291. BEGIN
  292.   var := VarList.head;
  293.   WHILE var # NIL DO
  294.     IF var(Variable).name^ = edG.Arg[0]^ THEN
  295.       DISPOSE(var(Variable).string);
  296.       SetString;
  297.       RETURN;
  298.     END;
  299.     var := var.next;
  300.   END;
  301.   len := str.Length(edG.Arg[0]^)+1;
  302.   ol.New(var,sys.SIZE(Variable)+len);
  303.   IF var = NIL THEN
  304.     edG.Rc := edE.cmdSevere; INCL(edG.Status,edG.memoryFail);
  305.     RETURN;
  306.   END;
  307.   (* $TypeChk- *)
  308.   sys.INIT(var(Variable)); (* $TypeChk= *)
  309.   var(Variable).name := sys.VAL(LONGINT,var)+sys.SIZE(Variable);
  310.   e.CopyMem(edG.Arg[0]^,var(Variable).name^,len);
  311.   lst.AddTail(VarList,var);
  312.   SetString;
  313. END doSet;
  314.  
  315.  
  316. PROCEDURE doSetEnv*;
  317. BEGIN
  318.   IF NOT sl.SetDEnv(edG.Arg[0]^,edG.Arg[1]^) THEN
  319.     edG.Rc := edE.cmdSevere;
  320.   END;
  321. END doSetEnv;
  322.  
  323.  
  324. PROCEDURE doUnsetEnv*;
  325. BEGIN
  326.   IF NOT sl.UnSetDEnv(edG.Arg[0]^) THEN
  327.     edG.Rc := edE.cmdSevere;
  328.   END;
  329. END doUnsetEnv;
  330.  
  331.  
  332. PROCEDURE doUnset*;
  333. VAR
  334.   var: lst.NodePtr;
  335.   len: INTEGER;
  336. BEGIN
  337.   var := VarList.head;
  338.   WHILE var # NIL DO
  339.     IF var(Variable).name^ = edG.Arg[0]^ THEN
  340.       ReleaseVar(var);
  341.       RETURN;
  342.     END;
  343.     var := var.next;
  344.   END;
  345. END doUnset;
  346.  
  347.  
  348. PROCEDURE FreeVars;
  349. VAR
  350.   var: lst.NodePtr;
  351. BEGIN
  352.   WHILE VarList.head#NIL DO
  353.     var := VarList.head;
  354.     VarList.head := var.next;
  355.     ReleaseVar(var);
  356.   END;
  357. END FreeVars;
  358.  
  359.  
  360. (* search order: (1) intern variables, (2) ENV:, (3) key-macros *)
  361.  
  362. PROCEDURE GetVar*(find: edG.StringPtr): edG.StringPtr;
  363. VAR
  364.   var: lst.NodePtr;
  365.   string, string2: edG.StringPtr;
  366.   len: INTEGER;
  367. BEGIN
  368.   IF    find^ = "findstr"  THEN RETURN edG.FindStr;
  369.   ELSIF find^ = "repstr"   THEN RETURN edG.ReplaceStr;
  370.   ELSIF find^ = "scanf"    THEN RETURN edG.ScanStr;
  371.   ELSIF find^ = "filename" THEN RETURN sys.ADR(edG.Text.name);
  372.   ELSIF find^ = "rexxport" THEN RETURN sys.ADR(edG.AEdrxPort);
  373.   ELSIF find^ = "colno"    THEN
  374.     IF cv.IntToString(LONG(edG.Text.pos+1),VarBuffer,12) THEN END;
  375.     RETURN sys.ADR(VarBuffer);
  376.   ELSIF find^ = "lineno"    THEN
  377.     IF cv.IntToString(edG.Text.line+1,VarBuffer,12) THEN END;
  378.     RETURN sys.ADR(VarBuffer);
  379.   END;
  380.   var := VarList.head;
  381.   WHILE var # NIL DO
  382.     IF var(Variable).name^ = find^ THEN
  383.       RETURN var(Variable).string; END;
  384.     var := var.next;
  385.   END;
  386.   string2 := sl.GetDEnv(find^);
  387.   IF string2 # NIL THEN
  388.     (*string := edL.CopyString(string2);
  389.     DISPOSE(string2); (* _muß_ DISPOSE sein, wg. Environment.mod *)*)
  390.     INCL(edG.Status,edG.disposeString);
  391.     RETURN string2;
  392.   END;
  393.   string2 := edK.KeySpectroMacro(find);
  394.   IF string2 = NIL THEN string2 := eMn.MenuToMacro(find); END;
  395.   RETURN string2;
  396. END GetVar;
  397.  
  398. (*-----------------------------------------------------------------------*)
  399.  
  400. PROCEDURE doFindStr*;
  401. VAR
  402.   sp: POINTER TO edG.StringPtr;
  403.   len: INTEGER;
  404. BEGIN
  405.   IF replace IN edG.ArgSet THEN sp := sys.ADR(edG.ReplaceStr);
  406.                   ELSE sp := sys.ADR(edG.FindStr); END;
  407.   DISPOSE(sp^);
  408.   sp^ := edL.CopyString(edG.Arg[0]);
  409. END doFindStr;
  410.  
  411. (*-----------------------------------------------------------------------*)
  412.  
  413. PROCEDURE Next{"FindNext"}(VAR findStruct{8}:FindReplaceStruct): LONGINT;
  414. PROCEDURE Prev{"FindPrev"}(VAR findStruct{8}:FindReplaceStruct): LONGINT;
  415.  
  416. PROCEDURE Replace;
  417. VAR
  418.   Rlen,Flen: INTEGER;
  419. BEGIN
  420.   Rlen := str.Length(edG.ReplaceStr^);
  421.   Flen := str.Length(edG.FindStr^);
  422.   IF NOT(edG.LineBufferLen+Rlen-Flen<edG.MaxLineLength) THEN
  423.     edG.Rc := edE.cmdError; edL.Title(ReplaceLineTooLong); RETURN;
  424.   END;
  425.   str.Delete(edG.LineBuffer,edG.Text.pos,Flen);
  426.   str.Insert(edG.LineBuffer,edG.Text.pos,edG.ReplaceStr^);
  427.   INC(edG.Text.pos,Rlen);
  428.   edD.PutBackLine;
  429.   edD.TextRedisplayCurrentLine;
  430. END Replace;
  431.  
  432.  
  433. PROCEDURE doFind*;
  434. VAR
  435.   LineChg: LONGINT;
  436.   FindData: FindReplaceStruct;
  437. BEGIN
  438.   edD.PutBackLine;
  439.   IF NOT (oldStrings IN edG.ArgSet) THEN
  440.     DISPOSE(edG.FindStr);
  441.     edG.FindStr := edL.CopyString(edG.Arg[0]);
  442.     IF replace IN edG.ArgSet THEN
  443.       DISPOSE(edG.ReplaceStr);
  444.       edG.ReplaceStr := edL.CopyString(edG.Arg[1]);
  445.       IF edG.multiMode IN edG.Status THEN EXCL(edG.ArgSet,replace); END;
  446.     END;
  447.     IF edG.memoryFail IN edG.Status THEN RETURN; END;
  448.   END;
  449.   IF edG.FindStr = NIL THEN
  450.     edG.Rc := edE.cmdError; edL.Title(NoFindPattern); RETURN; END;
  451.   IF (replace IN edG.ArgSet) AND (edG.ReplaceStr = NIL) THEN
  452.     edG.Rc := edE.cmdError; edL.Title(NoReplacePattern); RETURN; END;
  453.   FindData.findStr := edG.FindStr; FindData.flen := str.Length(edG.FindStr^);
  454.   FindData.line := edG.Text.actLinePtr; FindData.pos := edG.Text.pos+1;
  455.   LOOP
  456.     IF previous IN edG.ArgSet THEN LineChg := Prev(FindData);
  457.                               ELSE LineChg := Next(FindData); END;
  458.     IF (LineChg < 0) THEN
  459.       edG.Rc := edE.cmdFailed; edL.Title(PatternNotFound);
  460.       RETURN;
  461.     END;
  462.     edG.Text.actLinePtr := FindData.line; edG.Text.pos := FindData.pos;
  463.     IF previous IN edG.ArgSet THEN DEC(edG.Text.line,LineChg);
  464.                               ELSE INC(edG.Text.line,LineChg); END;
  465.     edD.TextLoad;
  466.     edD.TextSync;
  467.  
  468.     IF replace IN edG.ArgSet THEN
  469.       Replace;
  470.     ELSIF edG.multiMode IN edG.Status THEN
  471.       edL.Title(ReplaceQuestion); edG.Rc := edE.cmdValid2;
  472.     END;
  473.     IF ~((edG.multiMode IN edG.Status) & (replace IN edG.ArgSet))
  474.     OR (edG.Rc >= edE.AbortLevel) THEN
  475.       EXIT; END;
  476.     IF edL.BreakCheck() THEN edG.Rc := edE.cmdFailed; EXIT; END;
  477.     INC(FindData.pos,str.Length(edG.ReplaceStr^));
  478.   END;
  479. END doFind;
  480.  
  481. (*-----------------------------------------------------------------------*)
  482.  
  483. (**** multi-replace ***)
  484.  
  485. PROCEDURE doMultiReplace*;
  486. BEGIN
  487.   INCL(edG.Status,edG.multiMode);
  488.   doFind;
  489. END doMultiReplace;
  490.  
  491.  
  492. PROCEDURE MultiReplace*(IMsg: I.IntuiMessagePtr);
  493. VAR
  494.   Buffer: ARRAY 2 OF CHAR;
  495.   Blen: INTEGER;
  496. BEGIN
  497.   Blen := SHORT(sl.DeadKeyConvert(IMsg,Buffer,2,NIL));
  498.   IF Blen = 1 THEN
  499.      CASE Buffer[0] OF
  500.      "a": Replace;
  501.           IF edG.Rc < edE.AbortLevel THEN
  502.             edG.ArgSet := {replace,oldStrings};
  503.             doFind;
  504.             EXCL(edG.Status,edG.multiMode);
  505.           END;|
  506.      "y": Replace;
  507.           edG.ArgSet := {oldStrings};
  508.           doFind;|
  509.      "n": edG.ArgSet := {oldStrings};
  510.           doFind;|
  511.      "q",03X:  (* Ctrl-C *)
  512.           EXCL(edG.Status,edG.multiMode);
  513.           edG.Rc := edE.cmdValid1;  (* ob das so sinnvoll ist? *)
  514.           edL.WindowTitle;
  515.           RETURN;
  516.      ELSE
  517.      END;
  518.   END;
  519.   IF edG.Rc >= edE.AbortLevel THEN EXCL(edG.Status,edG.multiMode);
  520.   ELSIF edG.multiMode IN edG.Status THEN edL.Title(ReplaceQuestion); END;
  521. END MultiReplace;
  522.  
  523. (*-------------------------------------------------------------------------*)
  524.  
  525. PROCEDURE doNewWindow*;
  526. VAR
  527.   newText: edG.TextHeaderPtr;
  528.   nw: I.NewWindow;
  529. BEGIN
  530.   nw := edG.StdWindow;
  531.   e.CopyMemQuick(edG.Config.edges,nw.leftEdge,sys.SIZE(edG.Config.edges));
  532.   IF edG.TempHeight#0 THEN
  533.     nw.height := edG.TempHeight; edG.TempHeight := 0;
  534.   END;
  535.   IF edG.TempWidth #0 THEN
  536.     nw.width  := edG.TempWidth; edG.TempWidth := 0;
  537.   END;
  538.   IF edG.Screen # NIL THEN
  539.     nw.screen := edG.Screen;
  540.     nw.type := I.customScreen;
  541.   END;
  542.   newText := edL.TextInit(nw);
  543.   IF newText=NIL THEN
  544.     INCL(edG.Status,edG.memoryFail); edG.Rc := edE.cmdSevere;
  545.     RETURN;
  546.   END;
  547.   edD.SwitchEdit(newText);
  548. END doNewWindow;
  549.  
  550.  
  551. (* set LeftEdge/TopEdge/Width/Height/tempWidth/tempHeight *)
  552. PROCEDURE doWinEdges*;
  553. VAR
  554.   ip: POINTER TO INTEGER;
  555.   long: LONGINT;
  556. BEGIN
  557.   IF temp IN edG.ArgSet THEN
  558.     IF height IN edG.ArgSet THEN ip := sys.ADR(edG.TempHeight);
  559.                    ELSE ip := sys.ADR(edG.TempWidth); END;
  560.   ELSE
  561.     IF (leftEdge-edG.ArgSet={}) THEN ip := sys.ADR(edG.Config.edges.left);
  562.     ELSIF top IN edG.ArgSet     THEN ip := sys.ADR(edG.Config.edges.top);
  563.     ELSIF height IN edG.ArgSet THEN ip := sys.ADR(edG.Config.edges.height);
  564.                       ELSE ip := sys.ADR(edG.Config.edges.width); END;
  565.   END;
  566.   IF edL.StrToInt(edG.Arg[0],long) AND (long < MAX(INTEGER)) THEN
  567.     ip^ := ABS(SHORT(long));
  568.   ELSE
  569.     edL.Title(edG.BadArgument); edG.Rc := edE.cmdError;
  570.   END;
  571. END doWinEdges;
  572.  
  573.  
  574. PROCEDURE doResize*;
  575. VAR
  576.   Win: I.WindowPtr;
  577.   cols, rows: LONGINT;
  578.   width, height: INTEGER;
  579. BEGIN
  580.   IF NOT (edL.StrToInt(edG.Arg[0],cols))
  581.   OR NOT (edL.StrToInt(edG.Arg[1],rows)) THEN
  582.     edL.Title(edG.BadArgument); edG.Rc := edE.cmdError;
  583.   END;
  584.   Win := edG.Text.window;
  585.   width := (SHORT(cols)*Win.rPort.font.xSize)+Win.borderLeft+Win.borderRight;
  586.   height:= (SHORT(rows)*Win.rPort.font.ySize)+Win.borderTop+Win.borderBottom;
  587.   IF (width < 16) OR (height < 16)
  588.   OR (width > Win.wScreen.width - Win.leftEdge)
  589.   OR (height > Win.wScreen.height - Win.topEdge) THEN
  590.     edL.Title(WindowTooBig); edG.Rc := edE.cmdError;
  591.     RETURN;
  592.   END;
  593.   I.SizeWindow(Win,width-Win.width, height-Win.height);
  594.   edD.SetWindowParams;
  595.   d.Delay(50*2); (* wait 2 seconds *)
  596. END doResize;
  597.  
  598. (*-------------------------------------------------------------------------*)
  599.  
  600. PROCEDURE doMyPri*;
  601. VAR
  602.   long: LONGINT;
  603. BEGIN
  604.   IF edL.StrToInt(edG.Arg[0],long) AND (long<=MAX(SHORTINT))
  605.   AND (long>=MIN(SHORTINT)) THEN
  606.     IF e.SetTaskPri(e.FindTask(NIL),SHORT(SHORT(long))) = 0 THEN END;
  607.   ELSE
  608.     edL.Title(edG.BadArgument); edG.Rc := edE.cmdError;
  609.   END;
  610. END doMyPri;
  611.  
  612.  
  613. PROCEDURE doExecute*;
  614. VAR
  615.   OldLock: d.FileLockPtr;
  616. BEGIN
  617.   OldLock := d.CurrentDir(edG.Text.dirLock);
  618.   IF NOT d.Execute(edG.Arg[0]^,NIL,NIL) THEN
  619.     edG.Rc := edE.cmdFailed; edL.Title(ExecuteFailed); END;
  620.   OldLock := d.CurrentDir(OldLock);
  621. END doExecute;
  622.  
  623. (*-------------------------------------------------------------------------*)
  624.  
  625. BEGIN
  626.   lst.Init(VarList);
  627.   edG.FindStr := NIL; edG.ReplaceStr := NIL; edG.ScanStr := NIL;
  628.   edG.Screen := NIL;
  629.  
  630. CLOSE
  631.   IF edG.Screen # NIL THEN I.OldCloseScreen(edG.Screen); END;
  632.   FreeVars;
  633. END EdCmd2.
  634.  
  635.